{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.linear_model import LinearRegression, LogisticRegression, SGDRegressor\n",
    "import random\n",
    "linear = LinearRegression()\n",
    "logis = LogisticRegression()\n",
    "sgd = SGDRegressor(max_iter=1500000, learning_rate=\"constant\", eta0=0.00015)\n",
    "\n",
    "\n",
    "\n",
    "def fileToTrainDataSet(filepath):\n",
    "    df=pd.read_table(\"dataForTrainingLinear.txt\", delimiter=\" \",header=None)\n",
    "    df.columns = [\"square\", \"distance\", \"price\"]\n",
    "    linear_x_train = df.loc[:, \"square\":\"distance\"]\n",
    "    linear_y_train = df.loc[:, \"price\"]\n",
    "    return (linear_x_train, linear_y_train)\n",
    "\n",
    "def fileToTrainDataSet2(filepath):\n",
    "    df=pd.read_table(filepath, delimiter=\" \",header=None)\n",
    "    df.columns = [0,1,2,3,4,5,6]\n",
    "    linear_x_train = df.loc[:, 0:5]\n",
    "    linear_y_train = df.loc[:, 6]\n",
    "    return (linear_x_train, linear_y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, y_train = fileToTrainDataSet(\"dataForTrainingLinear.txt\")\n",
    "x_test, y_test = fileToTrainDataSet(\"dataForTestingLinear.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGDRegressor(alpha=0.0001, average=False, early_stopping=False, epsilon=0.1,\n",
       "             eta0=0.00015, fit_intercept=True, l1_ratio=0.15,\n",
       "             learning_rate='constant', loss='squared_loss', max_iter=1500000,\n",
       "             n_iter_no_change=5, penalty='l2', power_t=0.25, random_state=None,\n",
       "             shuffle=True, tol=0.001, validation_fraction=0.1, verbose=0,\n",
       "             warm_start=False)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd.fit(x_train, y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.17880194757683232"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd.score(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4.95846725 -9.88422639]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-0.00948117])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(sgd.coef_)\n",
    "sgd.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def compute_error(theta0, theta1, theta2, x_data, y_data):\n",
    "    totalError = 0\n",
    "    for i in range(0, len(x_data)):\n",
    "        totalError += (y_data[i] - (theta1 * x_data[i, 0] + theta2 * x_data[i, 1] + theta0)) ** 2\n",
    "    return totalError / float(len(x_data))\n",
    "\n",
    "\n",
    "def gradient_descent_runner(x_data, y_data, theta0, theta1, theta2, lr, epochs):\n",
    "    # 计算总数据量\n",
    "    m = float(len(x_data))\n",
    "    \n",
    "    err_list = []\n",
    "    re_list = []\n",
    "    \n",
    "    for i in range(epochs):\n",
    "        theta0_grad = 0\n",
    "        theta1_grad = 0\n",
    "        theta2_grad = 0\n",
    "        # 计算梯度的总和再求平均\n",
    "        \n",
    "        if i % 10000 == 0:\n",
    "            err_list.append(i)\n",
    "            re_list.append(compute_error(theta0,theta1,theta2, x_data, y_data))\n",
    "        \n",
    "        \n",
    "        for j in range(0, len(x_data)):\n",
    "            theta0_grad += -(1/m) * (y_data[j] - (theta1 * x_data[j, 0] + theta2*x_data[j, 1] + theta0))\n",
    "            theta1_grad += -(1 / m) * x_data[j, 0] * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0))\n",
    "            theta2_grad += -(1 / m) * x_data[j, 1] * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0))\n",
    "        #更新b和k\n",
    "        theta0 = theta0 - (lr*theta0_grad)\n",
    "        theta1 = theta1 - (lr*theta1_grad)\n",
    "        theta2 = theta2 - (lr*theta2_grad)\n",
    "    return theta0, theta1, theta2,err_list, re_list\n",
    "\n",
    "def random_gradient_descent_runner(x_data, y_data, theta0, theta1, theta2, lr, epochs):\n",
    "    # 计算总数据量\n",
    "    m = float(len(x_data))\n",
    "    \n",
    "    err_list = []\n",
    "    re_list = []\n",
    "    \n",
    "    for i in range(epochs):\n",
    "        theta0_grad = 0\n",
    "        theta1_grad = 0\n",
    "        theta2_grad = 0\n",
    "        # 计算梯度的总和再求平均\n",
    "        \n",
    "        if i % 100000 == 0:\n",
    "            err_list.append(i)\n",
    "            re_list.append(compute_error(theta0,theta1,theta2, x_data, y_data))\n",
    "        \n",
    "        \n",
    "        \n",
    "        j = random.randint(0,len(x_data)-1)\n",
    "        theta0_grad += -(1/m) * (y_data[j] - (theta1 * x_data[j, 0] + theta2*x_data[j, 1] + theta0))\n",
    "        theta1_grad += -(1 / m) * x_data[j, 0] * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0))\n",
    "        theta2_grad += -(1 / m) * x_data[j, 1] * (y_data[j] - (theta1 * x_data[j, 0] + theta2 * x_data[j, 1] + theta0))\n",
    "        #更新b和k\n",
    "        theta0 = theta0 - (lr*theta0_grad)\n",
    "        theta1 = theta1 - (lr*theta1_grad)\n",
    "        theta2 = theta2 - (lr*theta2_grad)\n",
    "    return theta0, theta1, theta2,err_list, re_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 50.9 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "x_arr = []\n",
    "y_arr = []\n",
    "for i in range(0,4000000, 100000):\n",
    "    t0,t1,t2,x,y=random_gradient_descent_runner(x_train.values, y_train.values, 0,0,0,0.00018, 200000)\n",
    "    x_arr.append(i)\n",
    "    y_arr.append(y[-1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1250199.2768916988,\n",
       " 49811245031.08894,\n",
       " 3918822.0396692995,\n",
       " 7090252837711159.0,\n",
       " 696472091.4461478,\n",
       " 8561592.911565544,\n",
       " 2053163.2135790898,\n",
       " 1.0198775228202476e+18,\n",
       " 957.9598530801643,\n",
       " 3285892435354000.5,\n",
       " 6875052194536.124,\n",
       " 6377122347172.769,\n",
       " 14169641587.574898,\n",
       " 108812810039218.52,\n",
       " 24978.69264463598,\n",
       " 2.0486583516313895e+25,\n",
       " 93795568022.8086,\n",
       " 60202077.34842979,\n",
       " 1.9195031608312988e+21,\n",
       " 2226.8408268932485,\n",
       " 24537833.284481674,\n",
       " 51151337.8821079,\n",
       " 104455735926.78918,\n",
       " 4704762472872.433,\n",
       " 95566131748259.66,\n",
       " 19633747431547.89,\n",
       " 38691.41326428417,\n",
       " 2162163393.8162484,\n",
       " 605844700775914.4,\n",
       " 2749976528760691.0,\n",
       " 2113997878183.7024,\n",
       " 2376.638554278117,\n",
       " 2087.7621892060165,\n",
       " 1115.7837355366162,\n",
       " 420293174.1940289,\n",
       " 1345657232.226659,\n",
       " 74085830.99664178,\n",
       " 1.2958358813665158e+22,\n",
       " 7.486391963955401e+23,\n",
       " 2.4006985287288744e+16]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "y_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x132d3754400>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "#解决中文显示问题\n",
    "plt.rcParams['font.sans-serif'] = ['simHei'] # 指定默认字体\n",
    "plt.rcParams['axes.unicode_minus'] = False # 解决保存图像是负号'-'显示为方块的问题\n",
    "plt.xlabel(\"迭代次数\", fontdict={'size': 16})\n",
    "plt.ylabel(\"误差\",fontdict={\"size\":16})\n",
    "plt.title(\"学习率为0.00018的误差值\", fontdict={'size': 20})\n",
    "plt.xticks(x_arr)\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (30.0, 12.0) # 单位是inches\n",
    "plt.scatter(x_arr,y_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "#逻辑回归\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, y_train = fileToTrainDataSet2(\"dataForTrainingLogistic.txt\")\n",
    "x_test, y_test = fileToTrainDataSet2(\"dataForTestingLogistic.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def compute_error(theta0, theta1, theta2, x_data, y_data):\n",
    "    totalError = 0\n",
    "    for i in range(0, len(x_data)):\n",
    "        totalError += (y_data[i] - (theta1 * x_data[i, 0] + theta2 * x_data[i, 1] + theta0)) ** 2\n",
    "    return totalError / float(len(x_data))\n",
    "\n",
    "\n",
    "def gradient_runner(x_data, y_data, thetas, lr, epochs):\n",
    "    # 计算总数据量\n",
    "    m = float(len(x_data))\n",
    "    \n",
    "    obj_vals = []\n",
    "    iter_vals= []    \n",
    "    for i in range(epochs):\n",
    "        \n",
    "        theta_grads = [0 for i in range(len(thetas))]\n",
    "        # 计算梯度的总和再求平均\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        for j in range(0, len(x_data)):\n",
    "            \n",
    "            linear_sum = thetas[0]\n",
    "            for k in range(len(thetas) - 1):\n",
    "                linear_sum += thetas[k + 1] * x_data[j,k]\n",
    "            hx = 1/(1+(math.exp(-1 * linear_sum)))\n",
    "                \n",
    "            theta_grads[0] += -(1/m) * (y_data[j] - hx)\n",
    "            theta_grads[1] += -(1/m) * (y_data[j] - hx) * x_data[j,0]\n",
    "            theta_grads[2] += -(1/m) * (y_data[j] - hx) * x_data[j,1]\n",
    "            theta_grads[3] += -(1/m) * (y_data[j] - hx) * x_data[j,2]\n",
    "            theta_grads[4] += -(1/m) * (y_data[j] - hx) * x_data[j,3]\n",
    "            theta_grads[5] += -(1/m) * (y_data[j] - hx) * x_data[j,4]\n",
    "            theta_grads[6] += -(1/m) * (y_data[j] - hx) * x_data[j,5]\n",
    "                    \n",
    "            \n",
    "          \n",
    "        for k in range(len(thetas)):\n",
    "            thetas[k] = thetas[k] - (lr * theta_grads[k])\n",
    "        \n",
    "        if i % 1000 == 0:\n",
    "            obj_val = 0\n",
    "            for j in range(0,len(x_data)):\n",
    "                linear_sum = thetas[0]\n",
    "                for k in range(len(thetas) - 1):\n",
    "                    linear_sum += thetas[k + 1] * x_data[j,k]\n",
    "                hx = 1/(1+(math.exp(-1 * linear_sum)))\n",
    "\n",
    "                obj_val += y_data[j] * math.log(hx)+(1-y_data[j]) * math.log(1-hx)\n",
    "            obj_vals.append(obj_val)\n",
    "            iter_vals.append(i)\n",
    "        \n",
    "    return thetas,obj_vals,iter_vals\n",
    "\n",
    "def predict(x_data, y_data,thetas):\n",
    "    # 计算总数据量\n",
    "    m = float(len(x_data))\n",
    "    \n",
    "   \n",
    "    re_list = []\n",
    "    \n",
    "    for j in range(0, len(x_data)):\n",
    "            \n",
    "            linear_sum = thetas[0]\n",
    "            for k in range(len(thetas) - 1):\n",
    "                linear_sum += thetas[k + 1] * x_data[j,k]\n",
    "            hx = 1/(1+(math.exp(-1 * linear_sum)))\n",
    "                \n",
    "            if hx > 0.5:\n",
    "                re_list.append(1)\n",
    "            else:\n",
    "                re_list.append(0)\n",
    "    return re_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "thetas, y,x = gradient_runner(x_train.values, y_train.values, [0,0,0,0,0,0,0],0.002, 20000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 0,\n",
       " 1,\n",
       " 1,\n",
       " 0,\n",
       " 0,\n",
       " 0,\n",
       " 1,\n",
       " 1]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_score = predict(x_test.values, 0,[0.36351947988627764,\n",
    "  -1.6852297594214287,\n",
    "  2.2415283582023338,\n",
    "  -1.7023145525369483,\n",
    "  2.1984876093027808,\n",
    "  -1.4257324449801754,\n",
    "  0.014884683728058101])\n",
    "\n",
    "y_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0     0\n",
       " 1     0\n",
       " 2     0\n",
       " 3     1\n",
       " 4     0\n",
       "      ..\n",
       " 95    0\n",
       " 96    0\n",
       " 97    0\n",
       " 98    1\n",
       " 99    1\n",
       " Name: 6, Length: 100, dtype: int64, 0      1\n",
       " 1      1\n",
       " 2      1\n",
       " 3      1\n",
       " 4      0\n",
       "       ..\n",
       " 395    1\n",
       " 396    1\n",
       " 397    0\n",
       " 398    1\n",
       " 399    0\n",
       " Name: 6, Length: 400, dtype: int64)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test,y_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(y_test)):\n",
    "    if y_test[i] != y_score[i]:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x132d74a5a90>"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "#解决中文显示问题\n",
    "plt.rcParams['font.sans-serif'] = ['simHei'] # 指定默认字体\n",
    "plt.rcParams['axes.unicode_minus'] = False # 解决保存图像是负号'-'显示为方块的问题\n",
    "plt.xlabel(\"迭代次数\", fontdict={'size': 16})\n",
    "plt.ylabel(\"目标函数值\",fontdict={\"size\":16})\n",
    "plt.title(\"目标函数值变化\", fontdict={'size': 20})\n",
    "plt.xticks(x)\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (30.0, 12.0) # 单位是inches\n",
    "plt.scatter(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "sizes = range(10,400,10)\n",
    "\n",
    "test_err = []\n",
    "train_err = []\n",
    "\n",
    "def err_check(err_list, arr1, arr2):\n",
    "    count = 0\n",
    "    for i in range(len(arr1)):\n",
    "        if (arr1[i] != arr2[i]):\n",
    "            count += 1\n",
    "    err_list.append(count)\n",
    "    \n",
    "for i in sizes:\n",
    "    x_train_size = x_train.sample(i)\n",
    "    y_train_size = y_train[x_train_size.index]\n",
    "    \n",
    "    thetas, y,x = gradient_runner(x_train_size.values, y_train_size.values,[0,0,0,0,0,0,0],0.002, 20000)\n",
    "    y_test_pre = predict(x_test.values, 0, thetas)\n",
    "    \n",
    "    \n",
    "    \n",
    "    err_check(test_err, y_test_pre, y_test.values)\n",
    "    \n",
    "    \n",
    "    \n",
    "    x_train_size = x_train.sample(i)\n",
    "    y_train_size = y_train[x_train_size.index]\n",
    "    y_train_pre = predict(x_train_size.values, 0, thetas)\n",
    "\n",
    "    err_check(train_err, y_train_pre, y_train_size.values)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 3, 0]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 1, 0]"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_err"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
